from machine import Pin, SPI
from os import uname
import time
import struct
from umqtt.simple import MQTTClient
import network

SSID="zidingyi"
PASSWORD="686685qbz"
SERVER = "175.178.93.60"
CLIENT_ID = "esp32"
topic1 = b"sensor"
topic2 = b"control"
username='2040707108'
password='asdzxc123'
c=None
def connectWifi(ssid,passwd):
  global wlan
  wlan = network.WLAN(network.STA_IF)        
  wlan.active(True)                   
  wlan.disconnect()               
  wlan.connect(ssid,passwd)
  while(wlan.ifconfig()[0] == '0.0.0.0'):
    time.sleep(1)


def recv_msg(topic, msg):
    if (topic==b"control"):
      if (msg==b"read"):
          do_read()
          
          c.wait_msg()
      elif (b"write" in msg):
          data=int(msg.decode('utf-8')[5:])
          global b
          if data is not None:
              b=struct.pack('b',data)+b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
              do_write()
              c.wait_msg()
      else:
          print("unknow message!")


class MFRC522:
    OK = 0
    NOTAGERR = 1
    ERR = 2
    REQIDL = 0x26
    REQALL = 0x52
    AUTHENT1A = 0x60
    AUTHENT1B = 0x61
    def __init__(self, sck, mosi, miso, rst, cs):
        self.sck = Pin(sck, Pin.OUT)
        self.mosi = Pin(mosi, Pin.OUT)
        self.miso = Pin(miso)
        self.rst = Pin(rst, Pin.OUT)
        self.cs = Pin(cs, Pin.OUT)
        self.rst.value(0)
        self.cs.value(1)
        board = uname()[0]
        self.spi = SPI(baudrate=100000, polarity=0, phase=0, sck=self.sck, mosi=self.mosi, miso=self.miso)
        self.spi.init()
        self.rst.value(1)
        self.init()
    def _wreg(self, reg, val):
        self.cs.value(0)
        self.spi.write(b'%c' % int(0xff & ((reg << 1) & 0x7e)))
        self.spi.write(b'%c' % int(0xff & val))
        self.cs.value(1)
    def _rreg(self, reg):
        self.cs.value(0)
        self.spi.write(b'%c' % int(0xff & (((reg << 1) & 0x7e) | 0x80)))
        val = self.spi.read(1)
        self.cs.value(1)
        return val[0]
    def _sflags(self, reg, mask):
        self._wreg(reg, self._rreg(reg) | mask)
    def _cflags(self, reg, mask):
        self._wreg(reg, self._rreg(reg) & (~mask))
    def _tocard(self, cmd, send):
        recv = []
        bits = irq_en = wait_irq = n = 0
        stat = self.ERR
        if cmd == 0x0E:
            irq_en = 0x12
            wait_irq = 0x10
        elif cmd == 0x0C:
            irq_en = 0x77
            wait_irq = 0x30
        self._wreg(0x02, irq_en | 0x80)
        self._cflags(0x04, 0x80)
        self._sflags(0x0A, 0x80)
        self._wreg(0x01, 0x00)
        for c in send:
            self._wreg(0x09, c)
        self._wreg(0x01, cmd)
        if cmd == 0x0C:
            self._sflags(0x0D, 0x80)
        i = 2000
        while True:
            n = self._rreg(0x04)
            i -= 1
            if ~((i != 0) and ~(n & 0x01) and ~(n & wait_irq)):
                break
        self._cflags(0x0D, 0x80)
        if i:
            if (self._rreg(0x06) & 0x1B) == 0x00:
                stat = self.OK
                if n & irq_en & 0x01:
                    stat = self.NOTAGERR
                elif cmd == 0x0C:
                    n = self._rreg(0x0A)
                    lbits = self._rreg(0x0C) & 0x07
                    if lbits != 0:
                        bits = (n - 1) * 8 + lbits
                    else:
                        bits = n * 8
                    if n == 0:
                        n = 1
                    elif n > 16:
                        n = 16
                    for _ in range(n):
                        recv.append(self._rreg(0x09))
            else:
                stat = self.ERR
        return stat, recv, bits
    def _crc(self, data):
        self._cflags(0x05, 0x04)
        self._sflags(0x0A, 0x80)
        for c in data:
            self._wreg(0x09, c)
        self._wreg(0x01, 0x03)
        i = 0xFF
        while True:
            n = self._rreg(0x05)
            i -= 1
            if not ((i != 0) and not (n & 0x04)):
                break
        return [self._rreg(0x22), self._rreg(0x21)]
    def init(self):
        self.reset()
        self._wreg(0x2A, 0x8D)
        self._wreg(0x2B, 0x3E)
        self._wreg(0x2D, 30)
        self._wreg(0x2C, 0)
        self._wreg(0x15, 0x40)
        self._wreg(0x11, 0x3D)
        self.antenna_on()
    def reset(self):
        self._wreg(0x01, 0x0F)
    def antenna_on(self, on=True):
        if on and ~(self._rreg(0x14) & 0x03):
            self._sflags(0x14, 0x03)
        else:
            self._cflags(0x14, 0x03)
    def request(self, mode):
        self._wreg(0x0D, 0x07)
        (stat, recv, bits) = self._tocard(0x0C, [mode])
        if (stat != self.OK) | (bits != 0x10):
            stat = self.ERR
        return stat, bits
    def anticoll(self):
        ser_chk = 0
        ser = [0x93, 0x20]
        self._wreg(0x0D, 0x00)
        (stat, recv, bits) = self._tocard(0x0C, ser)
        if stat == self.OK:
            if len(recv) == 5:
                for i in range(4):
                    ser_chk = ser_chk ^ recv[i]
                if ser_chk != recv[4]:
                    stat = self.ERR
            else:
                stat = self.ERR
        return stat, recv
    def select_tag(self, ser):
        buf = [0x93, 0x70] + ser[:5]
        buf += self._crc(buf)
        (stat, recv, bits) = self._tocard(0x0C, buf)
        return self.OK if (stat == self.OK) and (bits == 0x18) else self.ERR
    def auth(self, mode, addr, sect, ser):
        return self._tocard(0x0E, [mode, addr] + sect + ser[:4])[0]
    def stop_crypto1(self):
        self._cflags(0x08, 0x08)
    def read(self, addr):
        data = [0x30, addr]
        data += self._crc(data)
        (stat, recv, _) = self._tocard(0x0C, data)
        return recv if stat == self.OK else None
    def write(self, addr, data):
        buf = [0xA0, addr]
        buf += self._crc(buf)
        (stat, recv, bits) = self._tocard(0x0C, buf)
        if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):
            stat = self.ERR
        else:
            buf = []
            for i in range(16):
                buf.append(data[i])
            buf += self._crc(buf)
            (stat, recv, bits) = self._tocard(0x0C, buf)
            if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):
                stat = self.ERR
        return stat


def do_read():
    rdr = MFRC522(11, 10, 9, 5, 12)#sck, mosi, miso, rst, cs
    index = True ###用于标记是否读到卡片
    print('reading')
    try:
        while index:
            (stat, tag_type) = rdr.request(rdr.REQIDL)
            if stat == rdr.OK:
                (stat, raw_uid) = rdr.anticoll()
                if stat == rdr.OK:
                    print("识别到卡片：")
                    print("uid: 0x%02x%02x%02x%02x" % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
                    print("real:",raw_uid[0])
                    print("")
                    message1="uid: 0x%02x%02x%02x%02x" % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3])
                    c.publish(topic1,str(message1))
                    c.check_msg()
                    if rdr.select_tag(raw_uid) == rdr.OK:
                        key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
                        if rdr.auth(rdr.AUTHENT1A, 8, key, raw_uid) == rdr.OK:
                            print("Address 8 data: " , rdr.read(8))
                            abc="data:"+str(rdr.read(8)[0])
                            c.publish(topic1,abc)
                            c.check_msg()
                            rdr.stop_crypto1()
                            index = False
                            time.sleep(1)
                        else:
                            print("Authentication error")
    except KeyboardInterrupt:
      do_write()


def do_write():
    rdr = MFRC522(11, 10, 9, 5, 12)#sck, mosi, miso, rst, cs
    index = True
    print('write')
    global b
    try:
        while index:
            (stat, tag_type) = rdr.request(rdr.REQIDL)
            if stat == rdr.OK:
                (stat, raw_uid) = rdr.anticoll()
                if stat == rdr.OK:
                    print("uid: 0x%02x%02x%02x%02x" % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
                    print("")
                    if rdr.select_tag(raw_uid) == rdr.OK:
                        key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
                        if rdr.auth(rdr.AUTHENT1A, 8, key, raw_uid) == rdr.OK:
                            #write=input("输入你想写入的内容：")
                            stat = rdr.write(8,b)
                            rdr.stop_crypto1()
                            index = False
                            if stat == rdr.OK:
                                print("数据已写入")
                            else:
                                print("数据写入失败")
                        else:
                            print("Authentication error")
                    else:
                        print("Failed to select tag")
    except KeyboardInterrupt:
        print("receive")
        print('')
        c.wait_msg()


try:
    connectWifi(SSID,PASSWORD)
    server = SERVER
    c = MQTTClient(CLIENT_ID, server,1883,username,password)  
    c.set_callback(recv_msg)                  
    c.connect()                           
    c.subscribe(topic2)                      
    print("Connected to %s, subscribed to %s topic" % (server, topic2))
    while True:
        print("please send message from MQTT")
        c.wait_msg()
finally:
  if(c is not None):
    c.disconnect()
  wlan.disconnect()
  wlan.active(False)
